var express = require('express');
var router = express.Router();
// var fse = require('fs-extra');
const multer = require("multer");
const fs = require("fs");
const bodyParser = require("body-parser");
const path = require("path");
const cors = require("cors");
const uploadDir = path.join(__dirname, "../uploads"); // 上传目录

// 确保上传目录存在
if (!fs.existsSync(uploadDir)) {
  fs.mkdirSync(uploadDir);
}
// 检查已上传的分片
router.post("/check", (req, res) => {
  const { fileHash } = req.body;
  console.log("fileHash check",fileHash)
 
  const fileChunkDir = path.join(uploadDir, fileHash); // 分片存储目录
  if (!fs.existsSync(fileChunkDir)) {
    return res.json([]); // 如果目录不存在，返回空数组
  }
 
  // 返回已上传的分片索引
  const uploadedChunks = fs.readdirSync(fileChunkDir).map((chunk) => {
    return parseInt(chunk.split("-")[1]); // 提取分片索引
  });
  res.json(uploadedChunks);
});
 
 
// 设置 multer 中间件，用于处理文件上传
const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    const fileHash = req.query.fileHash; // 从查询参数获取 fileHash
    const chunkDir = path.join(uploadDir, fileHash);
    // 确保切片目录存在
    if (!fs.existsSync(chunkDir)) {
      fs.mkdirSync(chunkDir, { recursive: true });
    }
    cb(null, chunkDir);
  },
  filename: (req, file, cb) => {
    const { chunkIndex } = req.query;
    cb(null, `chunk-${chunkIndex}`);
  },
});
 
const upload = multer({ storage:storage });
 
// 上传文件分片
router.post("/upload", upload.single("chunk"), (req, res) => {
    const { fileHash } = req.body;
    res.status(200).send("分片上传成功");
});
 
 
// 合并分片
router.post("/merge", (req, res) => {
  const { fileName, fileHash, totalChunks } = req.body;
  console.log("fileName",req.body)
  const fileChunkDir = path.join(uploadDir, fileHash);
  const filePath = path.join(uploadDir, fileName);
 
  // 创建可写流用于最终合并文件
  const writeStream = fs.createWriteStream(filePath);
 
  for (let i = 0; i < totalChunks; i++) {
    const chunkPath = path.join(fileChunkDir, `chunk-${i}`);
    const data = fs.readFileSync(chunkPath); // 读取分片
    writeStream.write(data); // 写入最终文件
    // fs.unlinkSync(chunkPath); // 删除分片文件--留下来，可以看上传记录
  }
 
  writeStream.end(); // 关闭流
//   fs.rmdirSync(fileChunkDir); // 删除分片目录--留下来，可以看上传记录
  res.send("文件合并完成");
});

// const UPLOAD_DIR = path.resolve(__dirname, '../uploads');
// // 提取文件后缀名
// const extractExt = filename => {
//     return filename.slice(filename.lastIndexOf('.'), filename.length);
// };

// router.use(bodyParser.json());

// // 上传分片
// router.post('/upload', function (req, res) {
//     const form = new multiparty.Form();

//     form.parse(req, async (err, fields, files) => {
//         if (err) {
//             console.error('解析表单出错:', err);
//             return res.status(400).json({
//                 ok: false,
//                 msg: '解析表单出错，请重新上传'
//             });
//         }
//         const fileHash = fields['fileHash'][0];
//         const chunkHash = fields['chunkHash'][0];

//         // 临时存放切片的文件夹 
//         const chunkDir = path.resolve(UPLOAD_DIR, fileHash);

//         // 如果目录不存在，则创建一个新的
//         if (!fse.existsSync(chunkDir)) {
//             try {
//                 await fse.mkdirs(chunkDir);
//             } catch (mkdirErr) {
//                 console.error('创建目录出错:', mkdirErr);
//                 return res.status(500).json({
//                     ok: false,
//                     msg: '创建目录出错，请重新上传'
//                 });
//             }
//         }

//         // 如果存在，将所有的切片放到对应的目录里面
//         const oldPath = files['chunk'][0]['path'];
//         try {
//             await fse.move(oldPath, path.resolve(chunkDir, chunkHash));
//         } catch (moveErr) {
//             console.error('移动文件出错:', moveErr);
//             return res.status(500).json({
//                 ok: false,
//                 msg: '移动文件出错，请重新上传'
//             });
//         }

//         res.status(200).json({
//             ok: true,
//             msg: '上传成功'
//         });
//     });
// });

// // 合并分片
// router.post('/merge', async function (req, res) {
//     const { fileHash, fileName, size } = req.body;
//     console.log('接收到合并请求，fileHash:', fileHash, 'fileName:', fileName);

//     const filePath = path.resolve(UPLOAD_DIR, fileHash + extractExt(fileName));
//     const chunkDir = path.resolve(UPLOAD_DIR, fileHash);

//     if (fse.existsSync(filePath)) {
//         console.log('文件已存在，无需合并');
//         return res.status(200).json({
//             ok: true,
//             msg: '合并成功，文件已存在'
//         });
//     }

//     if (!fse.existsSync(chunkDir)) {
//         console.log('分片目录不存在，合并失败');
//         return res.status(410).json({
//             ok: false,
//             msg: '合并失败，请重新上传'
//         });
//     }

//     const allChunks = await fse.readdir(chunkDir);

//     allChunks.sort((a, b) => {
//         return parseInt(a.split('-')[1]) - parseInt(b.split('-')[1]);
//     });

//     const list = allChunks.map((chunkPath, index) => {
//         return new Promise((resolve, reject) => {
//             const readSream = fse.createReadStream(path.resolve(chunkDir, chunkPath));
//             const writeSream = fse.createWriteStream(filePath, {
//                 start: index * size,
//                 end: (index + 1) * size
//             });

//             readSream.on('end', async () => {
//                 try {
//                     await fse.unlink(path.resolve(chunkDir, chunkPath));
//                     resolve();
//                 } catch (unlinkErr) {
//                     reject(unlinkErr);
//                 }
//             });

//             readSream.on('error', reject);
//             readSream.pipe(writeSream);
//         });
//     });

//     try {
//         await Promise.all(list);
//         await fse.rmdirSync(chunkDir);
//         console.log('合并成功');
//         res.status(200).json({
//             ok: true,
//             msg: '合并成功',
//             test: 'uploads/' + fileHash + extractExt(fileName)
//         });
//     } catch (mergeErr) {
//         console.error('合并出错:', mergeErr);
//         res.status(500).json({
//             ok: false,
//             msg: '合并出错，请重新上传'
//         });
//     }
// });

// // 验证文件是否需要上传
// router.post('/verify', async function (req, res) {
//     const { fileHash, fileName } = req.body;

//     const filePath = path.resolve(UPLOAD_DIR, fileHash + extractExt(fileName));
//     const chunkDir = path.resolve(UPLOAD_DIR, fileHash);

//     let allChunks = [];
//     // 拿到之前已经上传过的分片
//     if (fse.existsSync(chunkDir)) {
//         allChunks = await fse.readdir(chunkDir);
//     }

//     if (fse.existsSync(filePath)) {
//         res.status(200).json({
//             ok: true,
//             data: {
//                 shouldUpload: false,
//                 test: fileHash + extractExt(fileName)
//             }
//         });
//     } else {
//         res.status(200).json({
//             ok: true,
//             data: {
//                 shouldUpload: true,
//                 existsChunks: allChunks,
//             }
//         });
//     }
// });

// // 上传封面
// router.post('/uploades', async (req, res) => {
//     const form = new multiparty.Form();
//     form.uploadDir = 'upload';
//     form.parse(req, async (error, fields, files) => {
//         if (error) {
//             console.error('解析表单出错:', error);
//             return res.status(400).json({
//                 ok: false,
//                 msg: '解析表单出错，请重新上传'
//             });
//         }
//         res.send({
//             ok: true,
//             msg: '上传成功',
//             path: 'http://127.0.0.1:3000/' + files.file[0].path
//         });
//     });
// });

module.exports = router;